home *** CD-ROM | disk | FTP | other *** search
/ Delphi Magazine Collection 2001 / Delphi Magazine Collection 20001 (2001).iso / DISKS / Issue67 / express / Parser10.txt < prev    next >
Text File  |  1997-08-20  |  4KB  |  142 lines
  1.   TParser parses and evaluates mathematical expressions 
  2. specified at runtime. Its performance is remarkable 
  3. - only 40-80% slower than similar compiled expression -
  4. and it is by far the fastest parser on the freeware market.
  5.  
  6.  
  7.   Quickstart:
  8.   -----------
  9.   [Some versions of TParser come with a comprehensive
  10.    online documenation ]
  11.  
  12.   The programming interface is simple:
  13.   - specify values for predefined variables in properties 
  14.      A,B,C,D,E,X,Y or T;
  15.   - optionally add new variables or removing existing ones;
  16.   - specify expression to be evaluated in Expression property;
  17.   - optionally change value of variables
  18.   - retrieve computed value in Value property. 
  19.  
  20.   Example:
  21.     Parser1.X := 100;
  22.     Parser1.Y := 200;
  23.     Parser1.Variable['z'] := 20;
  24.     Parser1.Expression := 'sin(x)*cos(y)+z';
  25.     Result := Parser1.Value;
  26.  
  27.   If you want to compute several values of the same 
  28. expression with different sets of variables, specify the
  29. expression once ONLY as this operation is rather time 
  30. consuming, then assign new values for variables and 
  31. retrieve the Value property as many times as you wish. 
  32.  
  33.  
  34.   Example:
  35.  
  36.     for i := 1 to 100 do
  37.     begin
  38.       Parser1.X := i;
  39.       Result := Parser1.Value;
  40.     end;
  41.  
  42.   You also may add your own variables by specifying their 
  43. names and values using the SetVariable method, accessing 
  44. them via a property or through direct memory access.
  45. (as usual variable names are not case-sensitive).
  46.  
  47.   Example (the following lines are all equivalent):
  48.  
  49. (1) Parser1.Variable['Test'] := 100;
  50.     Test := Parser1.Variable['Test'];
  51.  
  52. (2) Parser1.SetVariable('Test', 100);
  53.     Test := Parser1.GetVariable('Test');
  54.  
  55. (3) var
  56.       PTest : PParserFloat; { pointer to memory }
  57.  
  58.       PTest := Parser1.SetVariable('Test', 100);
  59.       PTest^ := 200; { set 'Test' = 200 }    
  60.       Test := PTest^;
  61.  
  62.   There is no limit for expression length in the 32bit version, 
  63. while the 16bit version has a restriction of 255 characters.
  64.  
  65.  
  66.   Predefined variables:
  67.     PI
  68.   
  69.   Accepted operators: + , - , * , / , ^ , MOD, DIV
  70.   [ MOD and DIV implicitly perform a trunc() on their operands ]
  71.  
  72.   The following functions are supported; it doesn't matter
  73.   if you use lower or upper case:
  74.  
  75.   [ NOTE: to activate some additional functions you need to
  76.           remove the SpeedCompare conditional define
  77.           in PARSER10.PAS !   ]
  78.  
  79.     COS, SIN, SINH, COSH, TAN, COTAN, ARCTAN, ARG,
  80.  
  81.     EXP, LN, LOG10, LOG2, LOGN,
  82.  
  83.     SQRT, SQR, POWER, INTPOWER,
  84.  
  85.     MIN, MAX, ABS, TRUNC, INT, CEIL, FLOOR, 
  86.  
  87.     HEAV (heav(x) is =1 for x=>0 and =0 for x<0),
  88.     SIGN (sign(x) is 1 for x>1, 0 for x=0, -1 for x<0),
  89.     ZERO (zero(x) is 0 for x=0, 1 for x<>0),
  90.     PH (ph(x) = x - 2*pi*round(x/2/pi))
  91.     RND (rnd(x) = int(x) * Random)
  92.     RANDOM (random(X) = Random; the argument X is not used)
  93.    
  94.   Adding your own functions is easy, too.
  95.   Either use ...
  96.  
  97.     AddFunctionOneParam   or
  98.     AddFunctionTwoParam
  99.  
  100.   ... if you do not want to create a new class, or create a new
  101.   class, inheriting from TParser and add your functions to
  102.   the lists, as demonstrated in TParser.Create.
  103.  
  104.  
  105.   IMPORTANT:
  106.     DO NOT USE BLANKS (#32) IN THE EXPRESSION.
  107.     THE PARSER IS UNABLE TO HANDLE THESE
  108.     (and raises an exception in response).
  109.  
  110.   You can use bracketing (nestings) up to a level of 20.
  111.   This can be increased at the expense of stack consumption
  112.   by changing
  113.     maxBracketLevels = 20;
  114.   in P10BUILD.PAS. This should not be a problem.
  115.  
  116.   If you get a "Expression too complex" exception increase
  117.     maxLevelWidth = 50;
  118.   in P10BUILD.PAS. This should never happen.
  119.  
  120.   You can define your OWN variables at RUNTIME,
  121.   in code you will use
  122.  
  123.      Parser1.Variable.Add('NAME', 123456)
  124.  
  125.   or simply (but slow)
  126.  
  127.      Parser1.Variable['ANOTHER'] := 1.23
  128.  
  129.   See the demonstration program for better techniques.
  130.  
  131.  
  132.   IMPORTANT: 
  133.  
  134.   The used _mathematical_ routines behave exactly like Delphi
  135.   runtime code in case of errors. Some people feel that this is
  136.   a problem.
  137.  
  138.   This is not a parsing issue, but rather a lack of attention to
  139.   the actual maths part (which is sloppy - deliberately)... Most 
  140.   probably you will be using your own mathematical routines
  141.   which are faster, more reliable, and provide more functionality.
  142.